Knowledge Engineering with Software Agents

Increasingly diverse and useful information repositories are being made available over the World Wide Web (Web). However, information retrieved from the Web is often of limited use for problem solving because it lacks task-relevance, structure and context. This research draws on software agency as a medium through which modeldriven knowledge engineering techniques can be applied to the Web. The IMPS (Internet-based Multi-agent Problem Solving) architecture described here involves software agents that can conduct structured on-line knowledge acquisition using distributed knowledge sources. Agent-generated domain ontologies are used to guide a flexible system of autonomous agents arranged in a server architecture. Generic problem solving methods developed within the expert system community supply structure and context. 1 Knowledge Engineering and the Web Knowledge engineering is concerned with the development of knowledge-based (expert) systems to perform tasks. In knowledge engineering, the ‘knowledge acquisition bottleneck’ refers to the timeand resourceintensive process of getting the knowledge about a domain that is necessary to perform the required task. Some examples of domains (subject areas) are respiratory medicine, igneous petrology and electronic engineering. Knowledge engineers acquire knowledge of the domain from various sources and represent it in a form that can be used in a knowledge based system. It is particularly difficult to get access to human domain experts who are, by definition, rare and often very busy. Therefore it is usual to perform initial sessions of domain structuring and representation using available resources such as textbooks, manuals, and increasingly, electronic media. While the Web could be a valuable source of knowledge covering many subject areas, it also presents the problem that there is often simply too much information available to each Web user. Relevant facts are obscured by masses of irrelevant data. An analysis of the Web using the overlap between pairs of search engines to estimate its size gave a lower bound on the size of the “indexable Web” in December 1997 of 320 million pages (Lawrence and Giles 1998). This may be a serious underestimate of the size of the whole Web as search engines typically do not index documents hidden behind search forms and cannot index some documents, which use the “robot exclusion standard” or require authentication. The estimate also excludes dynamic onthe-fly information serving over the Web. This exclusion is significant because increasingly, the Web is being used as a gateway for dynamic information transfer rather than simple delivery of static HTML pages. Programs are interfaced (e.g. through CGI-bin scripts) to the Web to provide users with information compiled on-the-fly and tailored to their needs. Even the static content of the Web is continually changing. Information is constantly updated, links are changed or expire, and pages (or entire Web sites) are moved to new locations in virtual and real space. There are other factors to be considered when using information from the Web. It holds information in many different formats. Examples include institutional databases, FAQ lists, interactive programs, publications, statistics, descriptive texts, photographs, films, sound and animation. A knowledge engineer will usually wish to exploit more than one source of information. The use of multiple formats and the distributed nature of the Web make the integration of this information a non-trivial task. Firstly each piece of information must be retrieved from its location using network protocols, and re-represented in a common format. Secondly, the pieces of information must be integrated with respect to their meaning. This poses problems as information from different sources may have been created from different, possibly contradictory, perspectives on the subject concerned. Although the Web has become well established and influential, we are only just beginning to explore the From: AAAI Technical Report SS-99-03. Compilation copyright © 1999, AAAI (www.aaai.org). All rights reserved. potential of tools that retrieve collated information from it. The ability to filter and reassemble information in an appropriate structure and context will be increasingly important as more and more information becomes available on-line. This paper presents the IMPS (Internetbased Multi-agent Problem Solving) architecture. IMPS is an agent-based architecture driven by knowledge level models. It is designed to facilitate the retrieval and restructuring of information from the Web. Our purpose is to use the resulting knowledge as problem solving knowledge suitable for use in a knowledge based system. However, the approach could have wider applicability. A semantic distinction can be made at this point between information and knowledge. Knowledge can be thought of as the whole body of information that someone brings to bear to solve a problem. One salient feature of this definition of knowledge is the composition of individual items of information into a larger pattern. The other is the application of this information to reach a goal. The advent of the Internet has increased the amount of available electronic information. The Web holds information on a vast number of domains. However, it does not present convenient packages of domain knowledge indexed by the kind of problems to which they could be applied. Within each domain represented on the Web, information is available which could be used for solving many possible problems. IMPS uses an approach that extracts and transforms information based on two criteria. The approach considers firstly the subject or domain (e.g. geology, respiratory medicine, electronic engineering), and secondly the kind of task in which the information is to be used (e.g. classification of objects, diagnosis of faults in a system, scheduling a series of tasks). In effect, this approach describes on-line knowledge acquisition using knowledge level models. 1.1 Knowledge Level Models Knowledge level models are widely used for knowledge acquisition in the knowledge engineering community. The term harks back to Newell’s original distinction between the knowledge level and the symbol level (Newell 1982). These are ways of interpreting the behaviour of any agent seen by an external observer. The behavioral law used to understand the agent at the knowledge level is the principle of maximum rationality which states: "If an agent has knowledge that one of its actions will lead to one of its goals, then the agent will select that action". No further attempt is made at this level to delve into how the agent actually works. It is enough to know that it acts as if according to the principle of maximum rationality. The knowledge level is implemented by the symbol level. At the symbol level, the agent is seen as a mechanism acting over symbols, and its behaviour is described in these terms. This distinction has had a great influence on the knowledge engineering community, notably in the modeling approaches to building knowledge based systems. Here, the systems are viewed as models of expert problem solving behaviour. Using the knowledge level, this behaviour can be modeled in terms of knowledge content (i.e. epistemologically). However, while Newell’s conceptualization did not allow for any structure at the knowledge level, most of the knowledge level models (KL-models) used in knowledge based systems are highly structured (Van de Velde 1993). Different kinds of knowledge model generally represent a particular perspective on the knowledge level. Van de Velde points out that in practical terms, knowledge can be divided into relatively stable structures. A KL-model is a structure that is imposed on knowledge when it is being put to use in a class of problem situations The common feature of this class of problem situations may be that they are all in the same domain. In this case, the model imposed may be described as a domain model. This is a means of expressing domain knowledge in a precise, systematic way. For example, if the domain being considered was respiratory diseases, a domain model might contain knowledge about the structure and function of a pair of lungs. This model could be useful in various tasks within the domain. It could facilitate diagnosis of respiratory disease by providing a causal model for linking diseases to symptoms, or it could be used to classify respiratory diseases by their features. Alternatively, the common feature of the class of problem situations might be that they share a common task structure, although they appear in different domains. This would be true of classification problems in geology and electronic engineering. Say the problems were a) to classify an unknown igneous rock specimen b) to classify an unknown circuit component. In both cases, a knowledge model might be used which represents knowledge about the classes that the unknown object may belong to, the distinguishing attributes of those classes, and the features of the unknown object which may be matched against those attributes. This kind of model is known as a task model. There may be more than one way to solve problems that share a task model. For instance, there are many problem solving methods for carrying out classification tasks. A full knowledge level model would bring together the task model, domain model and problem solving method into a coherent model that is sufficient to solve the task. If this is the case, one may ask “Why use the separate models in the first place?”. One of the reasons that these different knowledge models are used is to guide knowledge acquisition. If a new domain is being tackled, a task model may impose a structure on knowledge that can guide acquisition, even though a full domain model has not yet been formed. For instance, in the case of rock classification, although nothing may be known about the features of rock, a knowledge engineer will know that they must try to acquire information about distinguishing properties of classes of rock. Another reason for using the separate models is the potential for knowledge reuse. Full knowledge level models will rarely be reused, as it is unlikely that knowledge engineers will encounter exactly the same problem again. However, domain models, task models and problem solving methods all have the potential to be reused in problems which are similar in domain (in the case of domain models), or task (in the case of task models and problem solving methods). 1.1.1 Problem Solving Methods Reusable problemsolving methods (PSMs) focus on the idea that certain kinds of common task (e.g. classification) can be tackled by using the same problem-solving behaviour (e.g. generate and test a set of hypotheses), regardless of the domain in which they appear. An abstract model of this behaviour is a problem solving method. This method relates the task and domain models together so that goals can be accomplished. Knowledge roles (e.g. object class, attribute) in the task model are instantiated by domain knowledge. The problem solving method performs transformations between the input roles of the task model (i.e. the information that is given to the problem solver) and the output roles (the solution which is expected of it). The separation of a problem solving method from domain knowledge has been used in various well-known knowledge acquisition methodologies (Weilinga et al. 1991) (Klinker et al. 1991) (Steels 1990) (Chandrasekaran 1986). What these approaches have in common is the use of a finite library of domain independent problem solving methods, which may need some tuning to suit the domain of application. Some methods, such as ‘generate and test’ or ‘heuristic search’ are so weak in their assumptions of domain knowledge that they can be applied to a wide range of tasks with little fine-tuning. However, these weak methods tend not to be very efficient. Stronger, more efficient methods have more requirements in terms of the type and structure of domain knowledge and are therefore less widely applicable (Bylander and Chandrasekaran 1988). Figure 1 shows a typical domain knowledge schema for classification. Additionally, problem solving methods are usually specified not as a homogenous whole, but as a series of components or inference steps. Each of these components describes a relatively independent step taken in the problem solving method. Each oval in Figure 2 represents an inference step taken in the pruning classification method. There is often some flexibility regarding the order these steps are taken in. The term grainsize refers to the size of these elemental components. Methods with larger grainsize – fewer and larger components – are less reusable and require more tuning for new uses. Therefore the approach is moving towards a smaller grainsize, with finer-grained problem-solving strategies which can be configured together to form a knowledge based system (Puerta et al. 1992) (Gil and Melz 1996). Knowledge based system metatools have appeared (Walther, Eriksson and Musen 1992) (Studer et al. 1996) which store reusable components in libraries and configure them according to the requirements of each application. Recently, researchers have begun to discuss the implications of the Internet for problem solving method reuse in particular and knowledge engineering in general (e.g. Benjamins 1997). Fensel (Fensel 1997) points out that one reason that actual reuse of PSMs hasn't occurred as often as it might is that the PSMs that have been implemented make strong assumptions on software and hardware environments that limit reuse in other environments. Although a PSM itself may be specified at the knowledge level, the symbol level implementation of these knowledge level models on a computer is a practical impediment to reuse. It is difficult to reuse a PSM that has been implemented in Lisp on a Mac in a system using C++ on a Unix machine although they may be compatible at the knowledge level. These kinds of limitations are bypassed in an Internet-based architecture, such as IMPS, which exploits the emerging open standards for interoperation in Web-based software, such as the platform-independent Java language. object